home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 15 / CU Amiga Magazine's Super CD-ROM 15 (1997)(EMAP Images)(GB)[!][issue 1997-10].iso / CUCD / Graphics / Ghostscript / source / gscie.h < prev    next >
C/C++ Source or Header  |  1996-04-26  |  17KB  |  481 lines
  1. /* Copyright (C) 1992, 1995 Aladdin Enterprises.  All rights reserved.
  2.   
  3.   This file is part of Aladdin Ghostscript.
  4.   
  5.   Aladdin Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author
  6.   or distributor accepts any responsibility for the consequences of using it,
  7.   or for whether it serves any particular purpose or works at all, unless he
  8.   or she says so in writing.  Refer to the Aladdin Ghostscript Free Public
  9.   License (the "License") for full details.
  10.   
  11.   Every copy of Aladdin Ghostscript must include a copy of the License,
  12.   normally in a plain ASCII text file named PUBLIC.  The License grants you
  13.   the right to copy, modify and redistribute Aladdin Ghostscript, but only
  14.   under certain conditions described in the License.  Among other things, the
  15.   License requires that the copyright notice and this notice be preserved on
  16.   all copies.
  17. */
  18.  
  19. /* gscie.h */
  20. /* Structures for CIE color algorithms */
  21. /* (requires gscspace.h, gscolor2.h) */
  22. #include "gsrefct.h"
  23. #include "gxctable.h"
  24.  
  25. /* Define the size of the Encode/Decode/Transform procedure value caches. */
  26. /* With the current design, these caches must all have the same size. */
  27. #ifndef CIE_LOG2_CACHE_SIZE
  28. #  define CIE_LOG2_CACHE_SIZE 9
  29. #endif
  30. #define gx_cie_log2_cache_size CIE_LOG2_CACHE_SIZE
  31. #define gx_cie_cache_size (1 << gx_cie_log2_cache_size)
  32.  
  33. /* Define whether to use fixed- or floating-point values in the caches. */
  34. /*#define CIE_CACHE_USE_FIXED*/
  35.  
  36. /* If we are using fixed-point values, define the number of fraction bits. */
  37. #define CIE_FIXED_FRACTION_BITS 12
  38. #ifndef CIE_FIXED_FRACTION_BITS
  39. /* Take as many bits as we can without having to multiply in two pieces. */
  40. #  define CIE_FIXED_FRACTION_BITS\
  41.      ((arch_sizeof_long * 8 - gx_cie_log2_cache_size) / 2 - 1)
  42. #endif
  43.  
  44. /* Define whether to interpolate between cached values. */
  45. #define CIE_CACHE_INTERPOLATE
  46.  
  47. /* Define whether to interpolate at all intermediate lookup steps. */
  48. /* This is computationally expensive and doesn't seem to improve */
  49. /* the accuracy of the result. */
  50. /*#define CIE_INTERPOLATE_INTERMEDIATE*/
  51.  
  52. /* Define whether to interpolate in the RenderTable. */
  53. /* This is computationally very expensive, so it is normally disabled. */
  54. #define CIE_RENDER_TABLE_INTERPOLATE
  55. #ifdef CIE_RENDER_TABLE_INTERPOLATE
  56. #  define CIE_CACHE_INTERPOLATE
  57. #endif
  58.  
  59. /* Mark code intended for later use. */
  60. /****** NOTE: this is also used in zcie.c. ******/
  61. /*#define NEW_CIE*/
  62.  
  63. #define float_lshift(v, nb) ((v) * (1L << (nb)))
  64. #define float_rshift(v, nb) ((v) * (1.0 / (1L << (nb))))
  65.  
  66. #ifdef CIE_CACHE_INTERPOLATE
  67. /* We have to have room for both a cache index and the interpolation bits */
  68. /* in a positive int (i.e., leaving 1 bit for the sign), plus a little slop. */
  69. /* The values for interpolation are cie_cached_values by default. */
  70. #  define _cie_interpolate_bits\
  71.      min(arch_sizeof_int * 8 - gx_cie_log2_cache_size - 2, 10)
  72. #  define _cix(i) ((i) >> _cie_interpolate_bits)
  73. #  define _cif(i) ((int)(i) & ((1 << _cie_interpolate_bits) - 1))
  74. #  define cie_interpolate_between(v0, v1, i)\
  75.      ((v0) + cie_cached_rshift(((v1) - (v0)) * _cif(i) +\
  76.                     (1 << (_cie_interpolate_bits - 1)),\
  77.                    _cie_interpolate_bits))
  78. #  define cie_interpolate(p, i)\
  79.      cie_interpolate_between((p)[_cix(i)], (p)[_cix(i) + 1], i)
  80. #  define cie_interpolate_fracs(p, i)\
  81.      ((p)[_cix(i)] + (frac)arith_rshift((long)((p)[_cix(i) + 1] - (p)[_cix(i)]) * _cif(i), _cie_interpolate_bits))
  82. #else
  83. #  define _cie_interpolate_bits 0
  84. #  define cie_interpolate_between(v0, v1, i) (v0)
  85. #  define cie_interpolate(p, i) ((p)[i])
  86. #  define cie_interpolate_fracs(p, i) ((p)[i])
  87. #endif
  88.  
  89. #ifdef CIE_CACHE_USE_FIXED
  90. typedef long cie_cached_value;
  91. #  define _cie_fixed_shift CIE_FIXED_FRACTION_BITS
  92. #  define float2cie_cached(v)\
  93.      ((cie_cached_value)float_lshift(v, _cie_fixed_shift))
  94. #  define cie_cached2float(v)\
  95.      float_rshift(v, _cie_fixed_shift)
  96. #  define cie_cached2int(v, fbits)\
  97.      arith_rshift(v, _cie_fixed_shift - (fbits))
  98. /* We are multiplying two cie_cached_values to produce a result that */
  99. /* lies between 0 and gx_cie_cache_size - 1.  If the intermediate result */
  100. /* might overflow, compute it in pieces (being a little sloppy). */
  101. #  define _cie_product_excess_bits\
  102.      (_cie_fixed_shift * 2 + gx_cie_log2_cache_size - (arch_sizeof_long * 8 - 1))
  103. #  define cie_cached_product2int(v, factor, fbits)\
  104.      (_cie_product_excess_bits > 0 ?\
  105.       arith_rshift( (v) * arith_rshift(factor, _cie_product_excess_bits) +\
  106.             arith_rshift(v, _cie_product_excess_bits) *\
  107.              ((factor) & ((1 << _cie_product_excess_bits) - 1)),\
  108.             _cie_fixed_shift * 2 - _cie_product_excess_bits - (fbits)) :\
  109.       arith_rshift((v) * (factor), _cie_fixed_shift * 2 - (fbits)))
  110. #  define cie_cached_rshift(v, n) arith_rshift(v, n)
  111. #else
  112. typedef float cie_cached_value;
  113. #  define float2cie_cached(v) (v)
  114. #  define cie_cached2float(v) (v)
  115. #  define cie_cached2int(v, fbits)\
  116.      ((int)float_lshift(v, fbits))
  117. #  define cie_cached_product2int(v, factor, fbits)\
  118.      ((int)float_lshift((v) * (factor), fbits))
  119. #  define cie_cached_rshift(v, n) float_rshift(v, n)
  120. #endif
  121.  
  122. /* ------ Common definitions ------ */
  123.  
  124. /*
  125.  * For the purposes of the CIE routines, we consider that all the vectors
  126.  * are column vectors, that the matrices are specified in column order
  127.  * (e.g., the matrix
  128.  *    [ A B C ]
  129.  *    [ D E F ]
  130.  *    [ G H I ]
  131.  * is represented as [A D G B E H C F I]), and that to transform a vector
  132.  * V by a matrix M, we compute M * V to produce another column vector.
  133.  * Note in particular that in order to produce a matrix M that is
  134.  * equivalent to transforming by M1 and then by M2, we must compute
  135.  * M = M2 * M1.  This probably isn't the most intuitive way to specify
  136.  * these things, but that's how the code turned out, and it isn't worth
  137.  * changing at this point.
  138.  */
  139.  
  140. /* A 3-element vector. */
  141. typedef struct gs_vector3_s {
  142.     float u, v, w;
  143. } gs_vector3;
  144.  
  145. /* A 3x3 matrix, stored in column order. */
  146. typedef struct gs_matrix3_s {
  147.     gs_vector3 cu, cv, cw;
  148.     bool is_identity;
  149. } gs_matrix3;
  150.  
  151. /* 3- and 4-element vectors of ranges. */
  152. typedef struct gs_range_s {
  153.     float rmin, rmax;
  154. } gs_range;
  155. typedef struct gs_range3_s {
  156.     gs_range ranges[3];
  157. } gs_range3;
  158. typedef struct gs_range4_s {
  159.     gs_range ranges[4];
  160. } gs_range4;
  161.  
  162. /* Client-supplied transformation procedures. */
  163. typedef struct gs_cie_common_s gs_cie_common;
  164. #ifdef NEW_CIE
  165. typedef struct gs_cie_abc_common_s gs_cie_abc_common;
  166. #else
  167. typedef struct gs_cie_abc_s gs_cie_abc_common;
  168. #endif
  169. typedef struct gs_cie_wbsd_s gs_cie_wbsd;
  170.  
  171. typedef float (*gs_cie_a_proc)(P2(floatp, const gs_cie_a *));
  172.  
  173. typedef float (*gs_cie_abc_proc)(P2(floatp, const gs_cie_abc *));
  174. typedef struct gs_cie_abc_proc3_s {
  175.   gs_cie_abc_proc procs[3];
  176. } gs_cie_abc_proc3;
  177.  
  178. typedef float (*gs_cie_def_proc)(P2(floatp, const gs_cie_def *));
  179. typedef struct gs_cie_def_proc3_s {
  180.   gs_cie_def_proc procs[3];
  181. } gs_cie_def_proc3;
  182.  
  183. typedef float (*gs_cie_defg_proc)(P2(floatp, const gs_cie_defg *));
  184. typedef struct gs_cie_defg_proc4_s {
  185.   gs_cie_defg_proc procs[4];
  186. } gs_cie_defg_proc4;
  187.  
  188. typedef float (*gs_cie_common_proc)(P2(floatp, const gs_cie_common *));
  189. typedef struct gs_cie_common_proc3_s {
  190.   gs_cie_common_proc procs[3];
  191. } gs_cie_common_proc3;
  192.  
  193. typedef float (*gs_cie_render_proc)(P2(floatp, const gs_cie_render *));
  194. typedef struct gs_cie_render_proc3_s {
  195.   gs_cie_render_proc procs[3];
  196. } gs_cie_render_proc3;
  197.  
  198. typedef float (*gs_cie_transform_proc)(P3(floatp, const gs_cie_wbsd *,
  199.   const gs_cie_render *));
  200. typedef struct gs_cie_transform_proc3_s {
  201.   gs_cie_transform_proc procs[3];
  202. } gs_cie_transform_proc3;
  203.  
  204. typedef frac (*gs_cie_render_table_proc)(P2(byte, const gs_cie_render *));
  205. typedef struct gs_cie_render_table_procs_s {
  206.   gs_cie_render_table_proc procs[4];
  207. } gs_cie_render_table_procs;
  208.  
  209. /* CIE white and black points. */
  210. typedef struct gs_cie_wb_s {
  211.     gs_vector3 WhitePoint;
  212.     gs_vector3 BlackPoint;
  213. } gs_cie_wb;
  214.  
  215. /* ------ Caches ------ */
  216.  
  217. /*
  218.  * Given that all the client-supplied procedures involved in CIE color
  219.  * mapping and rendering are monotonic, and given that we can determine
  220.  * the minimum and maximum input values for them, we can cache their values.
  221.  * This takes quite a lot of space, but eliminates the need for callbacks
  222.  * deep in the graphics code (particularly the image operator).
  223.  *
  224.  * The procedures, and how we determine their domains, are as follows:
  225.  
  226. Stage        Name        Domain determination
  227. -----        ----        --------------------
  228. pre-decode    DecodeDEF    RangeDEF
  229. pre-decode    DecodeDEFG    RangeDEFG
  230. color space    DecodeA        RangeA
  231. color space    DecodeABC    RangeABC
  232. color space    DecodeLMN    RangeLMN
  233. rendering    TransformPQR    RangePQR
  234.   (but depends on color space White/BlackPoints)
  235. rendering    EncodeLMN    RangePQR transformed by the inverse of
  236.                   MatrixPQR and then by MatrixLMN
  237. rendering    EncodeABC    RangeLMN transformed by MatrixABC
  238. rendering    RenderTable.T    [0..1]*m
  239.  
  240.  * Note that we can mostly cache the results of the color space procedures
  241.  * without knowing the color rendering parameters, and vice versa,
  242.  * because of the range parameters supplied in the dictionaries.
  243.  * Unfortunately, TransformPQR is an exception.
  244.  */
  245. /*
  246.  * The index into a cache is (value - base) * factor, where
  247.  * factor is computed as (cie_cache_size - 1) / (rmax - rmin).
  248.  */
  249. /*
  250.  * We have two kinds of caches: ordinary caches, where each value is
  251.  * a scalar, and vector caches, where each value is a gs_cached_vector3.
  252.  * The latter allow us to pre-multiply the values by one column of
  253.  * a gs_matrix3, avoiding multiplications at lookup time.
  254.  * Since we sometimes alias the two types of caches for access to
  255.  * the floats, values must come last.
  256.  */
  257. typedef struct cie_cache_params_s {
  258.     bool is_identity;        /* must come first */
  259.     float base, factor;
  260. } cie_cache_params;
  261. #define cie_cache_struct(sname, vtype)\
  262.   struct sname {\
  263.     cie_cache_params params;\
  264.     vtype values[gx_cie_cache_size];\
  265.   }
  266. typedef cie_cache_struct(gx_cie_cache_s, float) cie_cache_floats;
  267. typedef union gx_cie_scalar_cache_s {
  268.     cie_cache_floats floats;
  269.     cie_cache_struct(_scf, frac) fracs;
  270.     cie_cache_struct(_sci, int) ints;
  271. } gx_cie_scalar_cache;
  272. typedef struct cie_cached_vector3_s {
  273.     cie_cached_value u, v, w;
  274. } cie_cached_vector3;
  275. typedef struct cie_vector_cache_params_s {
  276.     bool is_identity;        /* must come first */
  277.     cie_cached_value base, factor, limit;
  278. } cie_vector_cache_params;
  279. typedef struct cie_cache_vectors_s {
  280.     cie_vector_cache_params params;    /* must come first for is_identity */
  281.     cie_cached_vector3 values[gx_cie_cache_size];
  282. } cie_cache_vectors;
  283. typedef union gx_cie_vector_cache_s {
  284.     cie_cache_floats floats;
  285.     cie_cache_vectors vecs;
  286. } gx_cie_vector_cache;
  287.  
  288. /* ------ Color space dictionaries ------ */
  289.  
  290. /* Elements common to all CIE dictionaries. */
  291. struct gs_cie_common_s {
  292.     gs_range3 RangeLMN;
  293.     gs_cie_common_proc3 DecodeLMN;
  294.     gs_matrix3 MatrixLMN;
  295.     gs_cie_wb points;
  296.         /* Following are computed when structure is initialized. */
  297.     struct {
  298.         gx_cie_scalar_cache DecodeLMN[3];
  299.     } caches;
  300. };
  301.  
  302. /* A CIEBasedA dictionary. */
  303. struct gs_cie_a_s {
  304.     gs_cie_common common;        /* must be first */
  305.     rc_header rc;
  306.     gs_range RangeA;
  307.     gs_cie_a_proc DecodeA;
  308.     gs_vector3 MatrixA;
  309.         /* Following are computed when structure is initialized. */
  310.     struct {
  311.         gx_cie_vector_cache DecodeA;  /* mult. by MatrixA */
  312.     } caches;
  313. };
  314. #define private_st_cie_a()    /* in zcie.c */\
  315.   gs_private_st_simple(st_cie_a, gs_cie_a, "gs_cie_a")
  316.  
  317. /* A CIEBasedABC dictionary. */
  318. #ifdef NEW_CIE
  319. struct gs_cie_abc_common_s {
  320.     gs_cie_common common;        /* must be first */
  321. #else
  322. struct gs_cie_abc_s {
  323.     gs_cie_common common;        /* must be first */
  324.     rc_header rc;
  325. #endif
  326.     gs_range3 RangeABC;
  327.     gs_cie_abc_proc3 DecodeABC;
  328.     gs_matrix3 MatrixABC;
  329.         /* Following are computed when structure is initialized. */
  330.     struct {
  331.         bool skipABC;
  332.         gx_cie_vector_cache DecodeABC[3];  /* mult. by MatrixABC */
  333.     } caches;
  334. };
  335. #ifdef NEW_CIE
  336. /* A CIEBasedABC dictionary. */
  337. struct gs_cie_abc_s {
  338.     gs_cie_abc_common abc;        /* must be first */
  339.     rc_header rc;
  340. };
  341. #endif
  342. #define private_st_cie_abc()    /* in zcie.c */\
  343.   gs_private_st_simple(st_cie_abc, gs_cie_abc, "gs_cie_abc")
  344.  
  345. /* A CIEBasedDEF dictionary. */
  346. /****** NOT IMPLEMENTED YET ******/
  347. struct gs_cie_def_s {
  348.     gs_cie_abc_common abc;            /* must be first */
  349. #ifndef NEW_CIE
  350.     rc_header rc;
  351. #endif
  352.     gs_range3 RangeDEF;
  353.     gs_cie_def_proc3 DecodeDEF;
  354.     gs_range3 RangeHIJ;
  355.     gx_color_lookup_table Table;        /* [NH][NI * NJ * 3] */
  356.     struct {
  357.         gx_cie_scalar_cache DecodeDEF[3];
  358.     } caches;
  359. };
  360. #define private_st_cie_def()    /* in zcie.c */\
  361.   gs_private_st_ptrs1(st_cie_def, gs_cie_def, "gs_cie_def",\
  362.     cie_def_enum_ptrs, cie_def_reloc_ptrs, Table.table)
  363.  
  364. /* A CIEBasedDEFG dictionary. */
  365. /****** NOT IMPLEMENTED YET ******/
  366. struct gs_cie_defg_s {
  367.     gs_cie_abc_common abc;            /* must be first */
  368. #ifndef NEW_CIE
  369.     rc_header rc;
  370. #endif
  371.     gs_range4 RangeDEFG;
  372.     gs_cie_defg_proc4 DecodeDEFG;
  373.     gs_range4 RangeHIJK;
  374.     gx_color_lookup_table Table;        /* [NH * NI][NJ * NK * 3] */
  375.     struct {
  376.         gx_cie_scalar_cache DecodeDEFG[4];
  377.     } caches;
  378. };
  379. #define private_st_cie_defg()    /* in zcie.c */\
  380.   gs_private_st_ptrs1(st_cie_defg, gs_cie_defg, "gs_cie_defg",\
  381.     cie_defg_enum_ptrs, cie_defg_reloc_ptrs, Table.table)
  382.  
  383. /* Default values for components */
  384. extern const gs_range3 Range3_default;
  385. extern const gs_range4 Range4_default;
  386. extern const gs_cie_defg_proc4 DecodeDEFG_default;
  387. extern const gs_cie_def_proc3 DecodeDEF_default;
  388. extern const gs_cie_abc_proc3 DecodeABC_default;
  389. extern const gs_cie_common_proc3 DecodeLMN_default;
  390. extern const gs_matrix3 Matrix3_default;
  391. extern const gs_range RangeA_default;
  392. extern const gs_cie_a_proc DecodeA_default;
  393. extern const gs_vector3 MatrixA_default;
  394. extern const gs_vector3 BlackPoint_default;
  395. extern const gs_cie_render_proc3 Encode_default;
  396. extern const gs_cie_transform_proc3 TransformPQR_default;
  397. extern const gs_cie_render_table_procs RenderTableT_default;
  398.  
  399. /* ------ Rendering dictionaries ------ */
  400.  
  401. struct gs_cie_wbsd_s {
  402.     struct { gs_vector3 xyz, pqr; } ws, bs, wd, bd;
  403. };
  404. /* The main dictionary */
  405. struct gs_cie_render_s {
  406.     rc_header rc;
  407.     gs_cie_wb points;
  408.     gs_matrix3 MatrixPQR;
  409.     gs_range3 RangePQR;
  410.     gs_cie_transform_proc3 TransformPQR;
  411.     gs_matrix3 MatrixLMN;
  412.     gs_cie_render_proc3 EncodeLMN;
  413.     gs_range3 RangeLMN;
  414.     gs_matrix3 MatrixABC;
  415.     gs_cie_render_proc3 EncodeABC;
  416.     gs_range3 RangeABC;
  417.     struct {
  418.         gx_color_lookup_table lookup;    /* if table is 0, other */
  419.                         /* members are not set */
  420.         gs_cie_render_table_procs T;
  421.     } RenderTable;
  422.         /* Following are computed when structure is initialized. */
  423.     gs_range3 DomainLMN;
  424.     gs_range3 DomainABC;
  425.     gs_matrix3 MatrixABCEncode;
  426.     cie_cached_value EncodeABC_base[3];
  427.     gs_matrix3 MatrixPQR_inverse_LMN;
  428.     gs_vector3 wdpqr, bdpqr;
  429.     struct {
  430.         gx_cie_vector_cache EncodeLMN[3];  /* mult. by M'ABCEncode */
  431.         gx_cie_scalar_cache EncodeABC[3];
  432.         gx_cie_scalar_cache RenderTableT[4];
  433.         bool RenderTableT_is_identity;
  434.     } caches;
  435. };
  436. #define private_st_cie_render()    /* in zcrd.c */\
  437.   gs_private_st_ptrs1(st_cie_render, gs_cie_render, "gs_cie_render",\
  438.     cie_render_enum_ptrs, cie_render_reloc_ptrs, RenderTable.lookup.table)
  439. /* RenderTable.lookup.table points to an array of st_const_string_elements. */
  440. #define private_st_const_string()    /* in gscie.c */\
  441.   gs_private_st_composite(st_const_string, gs_const_string, "gs_const_string",\
  442.     const_string_enum_ptrs, const_string_reloc_ptrs)
  443. extern_st(st_const_string_element);
  444. #define public_st_const_string_element()    /* in gscie.c */\
  445.   gs_public_st_element(st_const_string_element, gs_const_string,\
  446.     "gs_const_string[]", const_string_elt_enum_ptrs,\
  447.     const_string_elt_reloc_ptrs, st_const_string)
  448.  
  449. /* ------ Joint caches ------ */
  450.  
  451. /* This cache depends on both the color space and the rendering */
  452. /* dictionary -- see above. */
  453.  
  454. typedef struct gx_cie_joint_caches_s {
  455.     rc_header rc;
  456.     bool skipLMN;
  457.     gx_cie_vector_cache DecodeLMN[3];  /* mult. by dLMN_PQR */
  458.     gs_cie_wbsd points_sd;
  459.     gs_matrix3 MatrixLMN_PQR;
  460.     bool skipPQR;
  461.     gx_cie_vector_cache TransformPQR[3];  /* mult. by PQR_inverse_eLMN */
  462. } gx_cie_joint_caches;
  463. #define private_st_joint_caches() /* in gscie.c */\
  464.   gs_private_st_simple(st_joint_caches, gx_cie_joint_caches,\
  465.     "gx_cie_joint_caches")
  466.  
  467. /* Internal routines */
  468. typedef struct gs_for_loop_params_s {
  469.     float init, step, limit;
  470. } gs_for_loop_params;
  471. void gs_cie_cache_init(P4(cie_cache_params *, gs_for_loop_params *,
  472.   const gs_range *, client_name_t));
  473. void gs_cie_cache_to_fracs(P1(gx_cie_scalar_cache *));
  474. void gs_cie_abc_complete(P1(gs_cie_abc *));
  475. void gs_cie_a_complete(P1(gs_cie_a *));
  476. int gs_cie_render_init(P1(gs_cie_render *));
  477. int gs_cie_render_complete(P1(gs_cie_render *));
  478. gx_cie_joint_caches *gx_currentciecaches(P1(gs_state *));
  479. const gs_cie_common *gs_cie_cs_common(P1(gs_state *));
  480. void gs_cie_cs_complete(P2(gs_state *, bool));
  481.